// hardware_task_queue.h
#ifndef HARDWARE_TASK_QUEUE_H
#define HARDWARE_TASK_QUEUE_H

#include <QString>
#include <QDateTime>
#include <QVariant>
#include <QJsonObject>
#include <QJsonDocument>

// 任务类型枚举 - 更新以匹配数据库
enum class TaskType : int {
    START = 1,                      // 开始
    RUN_START = 1,                  // 开始
    RUN_STOP = 2,                   // 停止
    STOP = 2,                       // 停止
    ESTOP = 3,                      // 急停
    RESET = 4,                      // 初始化
    CAPTURE = 5,                    // 采集[图像处理全流程]
    MOTION_HOME = 6,                // 回归零位
    MOTION_SET_WORK_ORIGIN = 7,     // 设置工件原点
    MOTION_JOG = 8,                 // 点动
    MOTION_SET_SPEED = 9,           // 设置速度
    BOOST = 10,                     // 性能提升



    LOAD_MATERIAL = 11,             // 上料
    UNLOAD_MATERIAL = 12,           // 下料
    UPDATE_PARAMETERS = 50,         // 参数更新

    // 手动任务类型
    MANUAL_SINGLE_FRAME_CAPTURE = 40, // 单帧采集
    MANUAL_PREPROCESS_ROI_CLUSTER = 41, // 预处理 (ROI+聚类)
    MANUAL_DEFECT_DETECTION = 42,   // 缺陷检测
    MANUAL_DEFECT_DETECTION_SECONDARY = 43, // 缺陷检测(应该是路径规划)
    MANUAL_C5_UPLOAD = 44,          // c5.上传指令
    MANUAL_RUN_COMMAND = 45,        // 运行指令
    MANUAL_CLEAR_UPLOAD = 46,       // 清除上传的指令
    MANUAL_INITIALIZE = 47,         // 初始化
    MANUAL_INITIALIZE_SECONDARY = 48 // 初始化

};

// 任务状态枚举 - 更新以匹配数据库
enum class TaskStatus : int {
    PENDING = 0,      // 待执行
    EXECUTING = 1,    // 执行中
    SUCCESS = 2,      // 执行成功
    FAILED = 3,       // 执行失败
    CANCELLED = 4     // 已取消
};

// 优先级枚举 - 更新以匹配数据库
enum class Priority : int {
    NORMAL = 0,       // 普通
    HIGH = 1,         // 高
    URGENT = 2        // 紧急
};

// 添加任务执行结果结构体
struct TaskExecutionResult {
    qint64 taskId;
    bool success;
    QString message;
    QDateTime finishTime;

    TaskExecutionResult(qint64 id = 0, bool s = false, const QString& msg = "")
        : taskId(id), success(s), message(msg), finishTime(QDateTime::currentDateTime()) {}
};

// 硬件任务队列结构体
struct HardwareTaskQueue {
    // 主键ID
    long long id = 0;

    // 核心字段 - 匹配数据库表结构
    QString task_name;                       // 任务名称
    TaskType task_type = TaskType::MANUAL_INITIALIZE_SECONDARY;  // 任务类型
    int device_id = 0;                       // 设备标识ID
    QJsonObject task_params;                 // 任务参数，JSON格式
    Priority priority = Priority::NORMAL;    // 优先级
    TaskStatus status = TaskStatus::PENDING; // 状态
    QJsonObject status_params;               // 任务状态，JSON格式（新增）
    int retry_count = 0;                     // 重试次数
    int max_retry_count = 3;                 // 最大重试次数

    // 时间字段
    QDateTime execute_time;                  // 计划执行时间
    QDateTime start_time;                    // 实际开始时间
    QDateTime end_time;                      // 实际结束时间

    // 数据库自动生成的时间
    QDateTime created_time;                  // 创建时间
    QDateTime updated_time;                  // 更新时间

    // 其他字段
    QString result_message;                  // 执行结果信息
    QString created_by;                      // 创建者

    // 默认构造函数
    HardwareTaskQueue() {
        execute_time = QDateTime::currentDateTime();
    }

    // 转换为QVariantMap（用于插入/更新数据库）
    QVariantMap toVariantMap(bool includeReadonlyFields = false) const {
        QVariantMap map;

        // 核心字段
        map["task_name"] = task_name;
        map["task_type"] = static_cast<int>(task_type);
        map["device_id"] = device_id;

        // JSON参数转换为字符串
        if (!task_params.isEmpty()) {
            QJsonDocument doc(task_params);
            map["task_params"] = doc.toJson(QJsonDocument::Compact);
        }

        if (!status_params.isEmpty()) {
            QJsonDocument doc(status_params);
            map["status_params"] = doc.toJson(QJsonDocument::Compact);
        }

        map["priority"] = static_cast<int>(priority);
        map["status"] = static_cast<int>(status);
        map["retry_count"] = retry_count;
        map["max_retry_count"] = max_retry_count;

        // 业务时间字段
        if (execute_time.isValid())
            map["execute_time"] = execute_time;
        if (start_time.isValid())
            map["start_time"] = start_time;
        if (end_time.isValid())
            map["end_time"] = end_time;

        // 其他字段
        if (!result_message.isEmpty())
            map["result_message"] = result_message;
        if (!created_by.isEmpty())
            map["created_by"] = created_by;

        // 只读时间字段
        if (includeReadonlyFields) {
            if (created_time.isValid())
                map["created_time"] = created_time;
            if (updated_time.isValid())
                map["updated_time"] = updated_time;
        }

        return map;
    }

    // 从QVariantMap解析（从数据库读取时使用）
    void fromVariantMap(const QVariantMap& map) {
        // 核心字段
        if (map.contains("id")) id = map["id"].toLongLong();
        if (map.contains("task_name")) task_name = map["task_name"].toString();

        // 枚举字段转换
        if (map.contains("task_type"))
            task_type = static_cast<TaskType>(map["task_type"].toInt());
        if (map.contains("device_id"))
            device_id = map["device_id"].toInt();
        if (map.contains("priority"))
            priority = static_cast<Priority>(map["priority"].toInt());
        if (map.contains("status"))
            status = static_cast<TaskStatus>(map["status"].toInt());

        // JSON参数解析
        if (map.contains("task_params") && map["task_params"].isValid()) {
            QJsonDocument doc = QJsonDocument::fromJson(map["task_params"].toByteArray());
            if (doc.isObject()) {
                task_params = doc.object();
            }
        }

        if (map.contains("status_params") && map["status_params"].isValid()) {
            QJsonDocument doc = QJsonDocument::fromJson(map["status_params"].toByteArray());
            if (doc.isObject()) {
                status_params = doc.object();
            }
        }

        if (map.contains("retry_count")) retry_count = map["retry_count"].toInt();
        if (map.contains("max_retry_count")) max_retry_count = map["max_retry_count"].toInt();

        // 时间字段
        if (map.contains("execute_time")) execute_time = map["execute_time"].toDateTime();
        if (map.contains("start_time")) start_time = map["start_time"].toDateTime();
        if (map.contains("end_time")) end_time = map["end_time"].toDateTime();
        if (map.contains("created_time")) created_time = map["created_time"].toDateTime();
        if (map.contains("updated_time")) updated_time = map["updated_time"].toDateTime();

        // 其他字段
        if (map.contains("result_message")) result_message = map["result_message"].toString();
        if (map.contains("created_by")) created_by = map["created_by"].toString();
    }

    // 获取任务类型文本
    QString getTaskTypeText() const {
        switch (task_type) {
        case TaskType::CAPTURE: return "采集";
        case TaskType::RUN_START: return "开始";  // 使用 RUN_START 而不是 START
        case TaskType::RUN_STOP: return "停止";   // 使用 RUN_STOP 而不是 STOP
        case TaskType::ESTOP: return "急停";
        case TaskType::RESET: return "初始化";
        case TaskType::MOTION_HOME: return "回归零位";
        case TaskType::MOTION_SET_WORK_ORIGIN: return "设置工件原点";
        case TaskType::MOTION_JOG: return "点动";
        case TaskType::MOTION_SET_SPEED: return "设置速度";
        case TaskType::BOOST: return "性能提升";
        case TaskType::MANUAL_SINGLE_FRAME_CAPTURE: return "单帧采集";
        case TaskType::MANUAL_PREPROCESS_ROI_CLUSTER: return "预处理(ROI+聚类)";
        case TaskType::MANUAL_DEFECT_DETECTION: return "缺陷检测";
        case TaskType::MANUAL_DEFECT_DETECTION_SECONDARY: return "缺陷检测(路径规划)";
        case TaskType::MANUAL_C5_UPLOAD: return "C5上传指令";
        case TaskType::MANUAL_RUN_COMMAND: return "运行指令";
        case TaskType::MANUAL_CLEAR_UPLOAD: return "清除上传指令";
        case TaskType::MANUAL_INITIALIZE:
        case TaskType::MANUAL_INITIALIZE_SECONDARY: return "初始化";
        case TaskType::UPDATE_PARAMETERS: return "参数更新";

        default: return "未知任务";
        }
    }

    // 获取状态文本
    QString getStatusText() const {
        switch (status) {
        case TaskStatus::PENDING: return "待执行";
        case TaskStatus::EXECUTING: return "执行中";
        case TaskStatus::SUCCESS: return "执行成功";
        case TaskStatus::FAILED: return "执行失败";
        case TaskStatus::CANCELLED: return "已取消";
        default: return "未知状态";
        }
    }

    // 获取优先级文本
    QString getPriorityText() const {
        switch (priority) {
        case Priority::NORMAL: return "普通";
        case Priority::HIGH: return "高";
        case Priority::URGENT: return "紧急";
        default: return "未知";
        }
    }

    // 检查任务是否可以重试
    bool canRetry() const {
        return status == TaskStatus::FAILED && retry_count < max_retry_count;
    }

    // 检查任务是否已完成
    bool isFinished() const {
        return status == TaskStatus::SUCCESS ||
               status == TaskStatus::FAILED ||
               status == TaskStatus::CANCELLED;
    }

    // 获取任务持续时间
    qint64 getDurationMs() const {
        if (start_time.isValid() && end_time.isValid()) {
            return start_time.msecsTo(end_time);
        }
        return 0;
    }

    // 转换为字符串（用于调试）
    QString toString() const {
        return QString("任务ID: %1, 名称: %2, 类型: %3, 状态: %4, 创建: %5")
            .arg(id)
            .arg(task_name)
            .arg(getTaskTypeText())
            .arg(getStatusText())
            .arg(created_time.toString("MM-dd hh:mm"));
    }
};

#endif // HARDWARE_TASK_QUEUE_H
